
// source idl: com.erp.acaccount.ao.idl.ACAccountAo.java

#ifndef ACACCOUNTAO_STUB_4_APP_H
#define ACACCOUNTAO_STUB_4_APP_H

#include <string>
#include <sstream>
#include "app_platform/cmd_obj.h"
#include "c2cent/base/basestub4app.h"
#include "app_platform/cntl_info.h"
#include "app_platform/intf_serializable.h"
#include "app_platform/intf_service_object.h"
#include <set>	
#include "erp/acaccount/po/acitemsfilterpo_acaccount.h"	
#include <map>	
#include "erp/acaccount/po/bankaccountfilterpo_acaccount.h"	
#include <vector>	
#include "erp/acaccount/po/bankaccountpo_acaccount.h"	
#include "erp/acaccount/po/acitemspo_acaccount.h"	
#include "intf_acaccountao.h"

namespace erp
{
namespace acaccount
{
namespace ao
{
	#define ACACCOUNTAO_STUB4APP_VERSION "ERP_ACACCOUNT_AO___ACACCOUNTAO__STUB4APP_VERSION__1.0 2013-10-31 18:45:19"
    const std::string ACACCOUNTAO_STUB4APP_NOUSE = ACACCOUNTAO_STUB4APP_VERSION;

	const uint32_t ACACCOUNTAO_ADDANDUPDATEACITEMS_REQ_CMD_ID = 0xc0601805; /// 请求命令号
	const uint32_t ACACCOUNTAO_ADDANDUPDATEACITEMS_RESP_CMD_ID = 0xc0608805; /// 回应命令号
	

	const uint32_t ACACCOUNTAO_ADDANDUPDATEBANKACCOUNT_REQ_CMD_ID = 0xc0601803; /// 请求命令号
	const uint32_t ACACCOUNTAO_ADDANDUPDATEBANKACCOUNT_RESP_CMD_ID = 0xc0608803; /// 回应命令号
	

	const uint32_t ACACCOUNTAO_DELETEACITEMS_REQ_CMD_ID = 0xc0601806; /// 请求命令号
	const uint32_t ACACCOUNTAO_DELETEACITEMS_RESP_CMD_ID = 0xc0608806; /// 回应命令号
	

	const uint32_t ACACCOUNTAO_DELETEBANKACCOUNT_REQ_CMD_ID = 0xc0601804; /// 请求命令号
	const uint32_t ACACCOUNTAO_DELETEBANKACCOUNT_RESP_CMD_ID = 0xc0608804; /// 回应命令号
	

	const uint32_t ACACCOUNTAO_GETACITEMSBYFILTER_REQ_CMD_ID = 0xc0601808; /// 请求命令号
	const uint32_t ACACCOUNTAO_GETACITEMSBYFILTER_RESP_CMD_ID = 0xc0608808; /// 回应命令号
	

	const uint32_t ACACCOUNTAO_GETACITEMSBYSYSNOS_REQ_CMD_ID = 0xc0601807; /// 请求命令号
	const uint32_t ACACCOUNTAO_GETACITEMSBYSYSNOS_RESP_CMD_ID = 0xc0608807; /// 回应命令号
	

	const uint32_t ACACCOUNTAO_GETBANKACCOUNTBYFILTER_REQ_CMD_ID = 0xc0601802; /// 请求命令号
	const uint32_t ACACCOUNTAO_GETBANKACCOUNTBYFILTER_RESP_CMD_ID = 0xc0608802; /// 回应命令号
	

	const uint32_t ACACCOUNTAO_GETBANKACCOUNTBYSYSNOS_REQ_CMD_ID = 0xc0601801; /// 请求命令号
	const uint32_t ACACCOUNTAO_GETBANKACCOUNTBYSYSNOS_RESP_CMD_ID = 0xc0608801; /// 回应命令号
	


	const uint16_t ACACCOUNTAO_MAX_PROTOCAL_VERSION = 2; //>平台支持的最大协议版本号

///////////////////////////// STRUCTS /////////////////////////////////////////////////
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-10-31 18:45:19
 	 * @version 0
	 */	
	struct CAddAndUpdateACItemsReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		erp::acaccount::po::CACItemsPo aCItemsPo;
		std::string inReserve;
		std::string errmsg;
		uint64_t aCItemsSysNo;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return ACACCOUNTAO_ADDANDUPDATEACITEMS_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > ACACCOUNTAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			aCItemsPo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-10-31 18:45:19
 	 * @version 0
	 */	
	struct CAddAndUpdateACItemsResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		uint64_t aCItemsSysNo;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return ACACCOUNTAO_ADDANDUPDATEACITEMS_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & aCItemsSysNo;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-10-31 18:45:19
 	 * @version 0
	 */	
	struct CAddAndUpdateBankAccountReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		erp::acaccount::po::CBankAccountPo bankAccount;
		std::string inReserve;
		std::string errmsg;
		uint64_t bankAccountSysNo;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return ACACCOUNTAO_ADDANDUPDATEBANKACCOUNT_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > ACACCOUNTAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bankAccount.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-10-31 18:45:19
 	 * @version 0
	 */	
	struct CAddAndUpdateBankAccountResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		uint64_t bankAccountSysNo;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return ACACCOUNTAO_ADDANDUPDATEBANKACCOUNT_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & bankAccountSysNo;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-10-31 18:45:19
 	 * @version 0
	 */	
	struct CDeleteACItemsReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint64_t ACItemsSysNo;
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return ACACCOUNTAO_DELETEACITEMS_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > ACACCOUNTAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & ACItemsSysNo;
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-10-31 18:45:19
 	 * @version 0
	 */	
	struct CDeleteACItemsResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return ACACCOUNTAO_DELETEACITEMS_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-10-31 18:45:19
 	 * @version 0
	 */	
	struct CDeleteBankAccountReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint64_t bankAccountSysNo;
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return ACACCOUNTAO_DELETEBANKACCOUNT_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > ACACCOUNTAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & bankAccountSysNo;
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-10-31 18:45:19
 	 * @version 0
	 */	
	struct CDeleteBankAccountResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return ACACCOUNTAO_DELETEBANKACCOUNT_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-10-31 18:45:19
 	 * @version 0
	 */	
	struct CGetACItemsByFilterReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		erp::acaccount::po::CACItemsFilterPo bankAccountFilter;
		std::string inReserve;
		std::string errmsg;
		std::vector<erp::acaccount::po::CACItemsPo > aCItems;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return ACACCOUNTAO_GETACITEMSBYFILTER_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > ACACCOUNTAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bankAccountFilter.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-10-31 18:45:19
 	 * @version 0
	 */	
	struct CGetACItemsByFilterResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::vector<erp::acaccount::po::CACItemsPo > aCItems;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return ACACCOUNTAO_GETACITEMSBYFILTER_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & aCItems;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-10-31 18:45:19
 	 * @version 0
	 */	
	struct CGetACItemsBySysNosReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		std::set<uint64_t > sysNoList;
		std::string inReserve;
		std::string errmsg;
		std::map<uint64_t,erp::acaccount::po::CACItemsPo > aACItems;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return ACACCOUNTAO_GETACITEMSBYSYSNOS_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > ACACCOUNTAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & sysNoList;
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-10-31 18:45:19
 	 * @version 0
	 */	
	struct CGetACItemsBySysNosResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::map<uint64_t,erp::acaccount::po::CACItemsPo > aACItems;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return ACACCOUNTAO_GETACITEMSBYSYSNOS_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & aACItems;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-10-31 18:45:19
 	 * @version 0
	 */	
	struct CGetBankAccountByFilterReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		erp::acaccount::po::CBankAccountFilterPo bankAccountFilter;
		std::string inReserve;
		std::string errmsg;
		std::vector<erp::acaccount::po::CBankAccountPo > bankAccount;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return ACACCOUNTAO_GETBANKACCOUNTBYFILTER_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > ACACCOUNTAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bankAccountFilter.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-10-31 18:45:19
 	 * @version 0
	 */	
	struct CGetBankAccountByFilterResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::vector<erp::acaccount::po::CBankAccountPo > bankAccount;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return ACACCOUNTAO_GETBANKACCOUNTBYFILTER_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & bankAccount;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-10-31 18:45:19
 	 * @version 0
	 */	
	struct CGetBankAccountBySysNosReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		std::set<uint64_t > sysNoList;
		std::string inReserve;
		std::string errmsg;
		std::map<uint64_t,erp::acaccount::po::CBankAccountPo > bankAccount;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return ACACCOUNTAO_GETBANKACCOUNTBYSYSNOS_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > ACACCOUNTAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & sysNoList;
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-10-31 18:45:19
 	 * @version 0
	 */	
	struct CGetBankAccountBySysNosResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::map<uint64_t,erp::acaccount::po::CBankAccountPo > bankAccount;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return ACACCOUNTAO_GETBANKACCOUNTBYSYSNOS_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & bankAccount;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	class CACAccountAoStub4App : public c2cent::CBaseStub4App, public IACAccountAo,public IACAccountAoAsyc{
		public:
			uint32_t AddAndUpdateACItems(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::acaccount::po::CACItemsPo& aCItemsPo,
				const std::string& inReserve,
				std::string& errmsg,
				uint64_t& aCItemsSysNo,
				std::string& outReserve
			);
			
			uint32_t SendAddAndUpdateACItems(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::acaccount::po::CACItemsPo& aCItemsPo,
				const std::string& inReserve
		    );
		    uint32_t RecvAddAndUpdateACItems(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				uint64_t& aCItemsSysNo,
				std::string& outReserve
		    );
		    
		    uint32_t RecvAddAndUpdateACItems(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				uint64_t& aCItemsSysNo,
				std::string& outReserve
		    );
		    
		    uint32_t GetAddAndUpdateACItemsRespCmd(
		    );
			uint32_t AddAndUpdateBankAccount(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::acaccount::po::CBankAccountPo& bankAccount,
				const std::string& inReserve,
				std::string& errmsg,
				uint64_t& bankAccountSysNo,
				std::string& outReserve
			);
			
			uint32_t SendAddAndUpdateBankAccount(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::acaccount::po::CBankAccountPo& bankAccount,
				const std::string& inReserve
		    );
		    uint32_t RecvAddAndUpdateBankAccount(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				uint64_t& bankAccountSysNo,
				std::string& outReserve
		    );
		    
		    uint32_t RecvAddAndUpdateBankAccount(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				uint64_t& bankAccountSysNo,
				std::string& outReserve
		    );
		    
		    uint32_t GetAddAndUpdateBankAccountRespCmd(
		    );
			uint32_t DeleteACItems(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t ACItemsSysNo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
			);
			
			uint32_t SendDeleteACItems(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t ACItemsSysNo,
				const std::string& inReserve
		    );
		    uint32_t RecvDeleteACItems(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve
		    );
		    
		    uint32_t RecvDeleteACItems(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve
		    );
		    
		    uint32_t GetDeleteACItemsRespCmd(
		    );
			uint32_t DeleteBankAccount(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t bankAccountSysNo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
			);
			
			uint32_t SendDeleteBankAccount(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t bankAccountSysNo,
				const std::string& inReserve
		    );
		    uint32_t RecvDeleteBankAccount(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve
		    );
		    
		    uint32_t RecvDeleteBankAccount(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve
		    );
		    
		    uint32_t GetDeleteBankAccountRespCmd(
		    );
			uint32_t GetACItemsByFilter(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::acaccount::po::CACItemsFilterPo& bankAccountFilter,
				const std::string& inReserve,
				std::string& errmsg,
				std::vector<erp::acaccount::po::CACItemsPo >& aCItems,
				std::string& outReserve
			);
			
			uint32_t SendGetACItemsByFilter(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::acaccount::po::CACItemsFilterPo& bankAccountFilter,
				const std::string& inReserve
		    );
		    uint32_t RecvGetACItemsByFilter(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::vector<erp::acaccount::po::CACItemsPo >& aCItems,
				std::string& outReserve
		    );
		    
		    uint32_t RecvGetACItemsByFilter(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::vector<erp::acaccount::po::CACItemsPo >& aCItems,
				std::string& outReserve
		    );
		    
		    uint32_t GetGetACItemsByFilterRespCmd(
		    );
			uint32_t GetACItemsBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& sysNoList,
				const std::string& inReserve,
				std::string& errmsg,
				std::map<uint64_t,erp::acaccount::po::CACItemsPo >& aACItems,
				std::string& outReserve
			);
			
			uint32_t SendGetACItemsBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& sysNoList,
				const std::string& inReserve
		    );
		    uint32_t RecvGetACItemsBySysNos(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::map<uint64_t,erp::acaccount::po::CACItemsPo >& aACItems,
				std::string& outReserve
		    );
		    
		    uint32_t RecvGetACItemsBySysNos(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::map<uint64_t,erp::acaccount::po::CACItemsPo >& aACItems,
				std::string& outReserve
		    );
		    
		    uint32_t GetGetACItemsBySysNosRespCmd(
		    );
			uint32_t GetBankAccountByFilter(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::acaccount::po::CBankAccountFilterPo& bankAccountFilter,
				const std::string& inReserve,
				std::string& errmsg,
				std::vector<erp::acaccount::po::CBankAccountPo >& bankAccount,
				std::string& outReserve
			);
			
			uint32_t SendGetBankAccountByFilter(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::acaccount::po::CBankAccountFilterPo& bankAccountFilter,
				const std::string& inReserve
		    );
		    uint32_t RecvGetBankAccountByFilter(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::vector<erp::acaccount::po::CBankAccountPo >& bankAccount,
				std::string& outReserve
		    );
		    
		    uint32_t RecvGetBankAccountByFilter(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::vector<erp::acaccount::po::CBankAccountPo >& bankAccount,
				std::string& outReserve
		    );
		    
		    uint32_t GetGetBankAccountByFilterRespCmd(
		    );
			uint32_t GetBankAccountBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& sysNoList,
				const std::string& inReserve,
				std::string& errmsg,
				std::map<uint64_t,erp::acaccount::po::CBankAccountPo >& bankAccount,
				std::string& outReserve
			);
			
			uint32_t SendGetBankAccountBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& sysNoList,
				const std::string& inReserve
		    );
		    uint32_t RecvGetBankAccountBySysNos(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::map<uint64_t,erp::acaccount::po::CBankAccountPo >& bankAccount,
				std::string& outReserve
		    );
		    
		    uint32_t RecvGetBankAccountBySysNos(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::map<uint64_t,erp::acaccount::po::CBankAccountPo >& bankAccount,
				std::string& outReserve
		    );
		    
		    uint32_t GetGetBankAccountBySysNosRespCmd(
		    );
	};
	
	/**
	 *
 	 *  写入&更新经营类会计项目信息 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param ACItemsPo aCItemsPo: 经营类会计项目信息po，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param uint64_t aCItemsSysNo: 银行账户SysNo 		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CACAccountAoStub4App::AddAndUpdateACItems(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::acaccount::po::CACItemsPo& aCItemsPo,
				const std::string& inReserve,
				std::string& errmsg,
				uint64_t& aCItemsSysNo,
				std::string& outReserve
	)
	{
		CAddAndUpdateACItemsReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.aCItemsPo = aCItemsPo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.aCItemsSysNo = aCItemsSysNo;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(ACACCOUNTAO_ADDANDUPDATEACITEMS_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << ACACCOUNTAO_ADDANDUPDATEACITEMS_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CAddAndUpdateACItemsResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			aCItemsSysNo  = oResp.aCItemsSysNo;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CACAccountAoStub4App::SendAddAndUpdateACItems(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::acaccount::po::CACItemsPo& aCItemsPo,
				const std::string& inReserve
	)
	{
	    CAddAndUpdateACItemsReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.aCItemsPo = aCItemsPo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CACAccountAoStub4App::RecvAddAndUpdateACItems(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				uint64_t& aCItemsSysNo,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(ACACCOUNTAO_ADDANDUPDATEACITEMS_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << ACACCOUNTAO_ADDANDUPDATEACITEMS_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CAddAndUpdateACItemsResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			aCItemsSysNo  = oResp.aCItemsSysNo;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CACAccountAoStub4App::RecvAddAndUpdateACItems(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				uint64_t& aCItemsSysNo,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CAddAndUpdateACItemsResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			aCItemsSysNo  = oResp.aCItemsSysNo;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CACAccountAoStub4App::GetAddAndUpdateACItemsRespCmd(
	)
	{	    
	    return ACACCOUNTAO_ADDANDUPDATEACITEMS_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  写入银行账户信息 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param BankAccountPo bankAccount: 银行信息ddo，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param uint64_t bankAccountSysNo: 银行账户SysNo 		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CACAccountAoStub4App::AddAndUpdateBankAccount(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::acaccount::po::CBankAccountPo& bankAccount,
				const std::string& inReserve,
				std::string& errmsg,
				uint64_t& bankAccountSysNo,
				std::string& outReserve
	)
	{
		CAddAndUpdateBankAccountReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.bankAccount = bankAccount;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.bankAccountSysNo = bankAccountSysNo;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(ACACCOUNTAO_ADDANDUPDATEBANKACCOUNT_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << ACACCOUNTAO_ADDANDUPDATEBANKACCOUNT_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CAddAndUpdateBankAccountResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			bankAccountSysNo  = oResp.bankAccountSysNo;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CACAccountAoStub4App::SendAddAndUpdateBankAccount(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::acaccount::po::CBankAccountPo& bankAccount,
				const std::string& inReserve
	)
	{
	    CAddAndUpdateBankAccountReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.bankAccount = bankAccount;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CACAccountAoStub4App::RecvAddAndUpdateBankAccount(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				uint64_t& bankAccountSysNo,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(ACACCOUNTAO_ADDANDUPDATEBANKACCOUNT_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << ACACCOUNTAO_ADDANDUPDATEBANKACCOUNT_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CAddAndUpdateBankAccountResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			bankAccountSysNo  = oResp.bankAccountSysNo;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CACAccountAoStub4App::RecvAddAndUpdateBankAccount(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				uint64_t& bankAccountSysNo,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CAddAndUpdateBankAccountResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			bankAccountSysNo  = oResp.bankAccountSysNo;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CACAccountAoStub4App::GetAddAndUpdateBankAccountRespCmd(
	)
	{	    
	    return ACACCOUNTAO_ADDANDUPDATEBANKACCOUNT_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  逻辑删除经营类会计项目信息 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param uint64_t ACItemsSysNo: 会计项目信息SysNo 				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CACAccountAoStub4App::DeleteACItems(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t ACItemsSysNo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		CDeleteACItemsReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.ACItemsSysNo = ACItemsSysNo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(ACACCOUNTAO_DELETEACITEMS_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << ACACCOUNTAO_DELETEACITEMS_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CDeleteACItemsResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CACAccountAoStub4App::SendDeleteACItems(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t ACItemsSysNo,
				const std::string& inReserve
	)
	{
	    CDeleteACItemsReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.ACItemsSysNo = ACItemsSysNo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CACAccountAoStub4App::RecvDeleteACItems(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(ACACCOUNTAO_DELETEACITEMS_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << ACACCOUNTAO_DELETEACITEMS_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CDeleteACItemsResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CACAccountAoStub4App::RecvDeleteACItems(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CDeleteACItemsResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CACAccountAoStub4App::GetDeleteACItemsRespCmd(
	)
	{	    
	    return ACACCOUNTAO_DELETEACITEMS_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  逻辑删除银行账户信息 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param uint64_t bankAccountSysNo: 银行账户SysNo 				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CACAccountAoStub4App::DeleteBankAccount(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t bankAccountSysNo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		CDeleteBankAccountReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.bankAccountSysNo = bankAccountSysNo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(ACACCOUNTAO_DELETEBANKACCOUNT_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << ACACCOUNTAO_DELETEBANKACCOUNT_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CDeleteBankAccountResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CACAccountAoStub4App::SendDeleteBankAccount(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint64_t bankAccountSysNo,
				const std::string& inReserve
	)
	{
	    CDeleteBankAccountReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.bankAccountSysNo = bankAccountSysNo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CACAccountAoStub4App::RecvDeleteBankAccount(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(ACACCOUNTAO_DELETEBANKACCOUNT_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << ACACCOUNTAO_DELETEBANKACCOUNT_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CDeleteBankAccountResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CACAccountAoStub4App::RecvDeleteBankAccount(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CDeleteBankAccountResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CACAccountAoStub4App::GetDeleteBankAccountRespCmd(
	)
	{	    
	    return ACACCOUNTAO_DELETEBANKACCOUNT_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  Filter过滤获取经营类会计项目信息
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param ACItemsFilterPo bankAccountFilter: 过滤器，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param Vector aCItems: 经营类会计项目信息 Po列表 		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CACAccountAoStub4App::GetACItemsByFilter(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::acaccount::po::CACItemsFilterPo& bankAccountFilter,
				const std::string& inReserve,
				std::string& errmsg,
				std::vector<erp::acaccount::po::CACItemsPo >& aCItems,
				std::string& outReserve
	)
	{
		CGetACItemsByFilterReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.bankAccountFilter = bankAccountFilter;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.aCItems = aCItems;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(ACACCOUNTAO_GETACITEMSBYFILTER_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << ACACCOUNTAO_GETACITEMSBYFILTER_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetACItemsByFilterResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			aCItems  = oResp.aCItems;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CACAccountAoStub4App::SendGetACItemsByFilter(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::acaccount::po::CACItemsFilterPo& bankAccountFilter,
				const std::string& inReserve
	)
	{
	    CGetACItemsByFilterReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.bankAccountFilter = bankAccountFilter;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CACAccountAoStub4App::RecvGetACItemsByFilter(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::vector<erp::acaccount::po::CACItemsPo >& aCItems,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(ACACCOUNTAO_GETACITEMSBYFILTER_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << ACACCOUNTAO_GETACITEMSBYFILTER_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetACItemsByFilterResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			aCItems  = oResp.aCItems;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CACAccountAoStub4App::RecvGetACItemsByFilter(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::vector<erp::acaccount::po::CACItemsPo >& aCItems,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetACItemsByFilterResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			aCItems  = oResp.aCItems;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CACAccountAoStub4App::GetGetACItemsByFilterRespCmd(
	)
	{	    
	    return ACACCOUNTAO_GETACITEMSBYFILTER_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  通过SysNos获取经营类会计项目信息
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param Set sysNoList: 银行账户SysNo数组，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param Map aACItems: 经营类会计项目信息PO列表  		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CACAccountAoStub4App::GetACItemsBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& sysNoList,
				const std::string& inReserve,
				std::string& errmsg,
				std::map<uint64_t,erp::acaccount::po::CACItemsPo >& aACItems,
				std::string& outReserve
	)
	{
		CGetACItemsBySysNosReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.sysNoList = sysNoList;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.aACItems = aACItems;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(ACACCOUNTAO_GETACITEMSBYSYSNOS_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << ACACCOUNTAO_GETACITEMSBYSYSNOS_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetACItemsBySysNosResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			aACItems  = oResp.aACItems;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CACAccountAoStub4App::SendGetACItemsBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& sysNoList,
				const std::string& inReserve
	)
	{
	    CGetACItemsBySysNosReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.sysNoList = sysNoList;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CACAccountAoStub4App::RecvGetACItemsBySysNos(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::map<uint64_t,erp::acaccount::po::CACItemsPo >& aACItems,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(ACACCOUNTAO_GETACITEMSBYSYSNOS_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << ACACCOUNTAO_GETACITEMSBYSYSNOS_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetACItemsBySysNosResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			aACItems  = oResp.aACItems;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CACAccountAoStub4App::RecvGetACItemsBySysNos(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::map<uint64_t,erp::acaccount::po::CACItemsPo >& aACItems,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetACItemsBySysNosResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			aACItems  = oResp.aACItems;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CACAccountAoStub4App::GetGetACItemsBySysNosRespCmd(
	)
	{	    
	    return ACACCOUNTAO_GETACITEMSBYSYSNOS_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  获取银行账户信息 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param BankAccountFilterPo bankAccountFilter: 过滤器，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param Vector bankAccount: 银行信息列表  		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CACAccountAoStub4App::GetBankAccountByFilter(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::acaccount::po::CBankAccountFilterPo& bankAccountFilter,
				const std::string& inReserve,
				std::string& errmsg,
				std::vector<erp::acaccount::po::CBankAccountPo >& bankAccount,
				std::string& outReserve
	)
	{
		CGetBankAccountByFilterReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.bankAccountFilter = bankAccountFilter;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.bankAccount = bankAccount;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(ACACCOUNTAO_GETBANKACCOUNTBYFILTER_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << ACACCOUNTAO_GETBANKACCOUNTBYFILTER_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetBankAccountByFilterResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			bankAccount  = oResp.bankAccount;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CACAccountAoStub4App::SendGetBankAccountByFilter(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::acaccount::po::CBankAccountFilterPo& bankAccountFilter,
				const std::string& inReserve
	)
	{
	    CGetBankAccountByFilterReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.bankAccountFilter = bankAccountFilter;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CACAccountAoStub4App::RecvGetBankAccountByFilter(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::vector<erp::acaccount::po::CBankAccountPo >& bankAccount,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(ACACCOUNTAO_GETBANKACCOUNTBYFILTER_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << ACACCOUNTAO_GETBANKACCOUNTBYFILTER_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetBankAccountByFilterResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			bankAccount  = oResp.bankAccount;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CACAccountAoStub4App::RecvGetBankAccountByFilter(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::vector<erp::acaccount::po::CBankAccountPo >& bankAccount,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetBankAccountByFilterResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			bankAccount  = oResp.bankAccount;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CACAccountAoStub4App::GetGetBankAccountByFilterRespCmd(
	)
	{	    
	    return ACACCOUNTAO_GETBANKACCOUNTBYFILTER_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  通过SysNos获取银行账户信息 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param Set sysNoList: 银行账户SysNo数组，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param Map bankAccount: 银行账户信息列表  		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CACAccountAoStub4App::GetBankAccountBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& sysNoList,
				const std::string& inReserve,
				std::string& errmsg,
				std::map<uint64_t,erp::acaccount::po::CBankAccountPo >& bankAccount,
				std::string& outReserve
	)
	{
		CGetBankAccountBySysNosReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.sysNoList = sysNoList;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.bankAccount = bankAccount;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(ACACCOUNTAO_GETBANKACCOUNTBYSYSNOS_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << ACACCOUNTAO_GETBANKACCOUNTBYSYSNOS_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetBankAccountBySysNosResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			bankAccount  = oResp.bankAccount;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CACAccountAoStub4App::SendGetBankAccountBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& sysNoList,
				const std::string& inReserve
	)
	{
	    CGetBankAccountBySysNosReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.sysNoList = sysNoList;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CACAccountAoStub4App::RecvGetBankAccountBySysNos(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::map<uint64_t,erp::acaccount::po::CBankAccountPo >& bankAccount,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(ACACCOUNTAO_GETBANKACCOUNTBYSYSNOS_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << ACACCOUNTAO_GETBANKACCOUNTBYSYSNOS_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetBankAccountBySysNosResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			bankAccount  = oResp.bankAccount;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CACAccountAoStub4App::RecvGetBankAccountBySysNos(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::map<uint64_t,erp::acaccount::po::CBankAccountPo >& bankAccount,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetBankAccountBySysNosResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			bankAccount  = oResp.bankAccount;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CACAccountAoStub4App::GetGetBankAccountBySysNosRespCmd(
	)
	{	    
	    return ACACCOUNTAO_GETBANKACCOUNTBYSYSNOS_RESP_CMD_ID;
	}	
		
}
}
}

#endif /* ACACCOUNTAO_STUB_4_APP_H */
